package com.ruoyi.common.utils.calculate;


import com.ruoyi.common.utils.StringUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * 电机计算工具类
 */
public class MotorUtils {

    /* 功率箱参数 */
    public float uAb = 0f; // A相电压
    public float uBc = 0f; // B相电压
    public float uCa = 0f; // C相电压
    public float aA = 0f; // A相电流
    public float aB = 0f; // B相电流
    public float aC = 0f; // C相电流
    public float pjdy = 0f; // 平均电压
    public float pjdl = 0f; // 平均电流

    public float glys = 1f; // 功率因数

    /**
     * @param uAb  AB相电压
     * @param uBc  BC相电压
     * @param uCa  CA相电压
     * @param aA   A相电流
     * @param aB   B相电流
     * @param aC   C相电流
     * @param pjdy 平均电压
     * @param pjdl 平均电流
     */
    public MotorUtils(String uAb, String uBc, String uCa, String aA, String aB, String aC, String pjdy, String pjdl) {
        this.uAb = !StringUtils.isEmpty(uAb) ? Float.parseFloat(uAb) : 0f;
        this.uBc = !StringUtils.isEmpty(uBc) ? Float.parseFloat(uBc) : 0f;
        this.uCa = !StringUtils.isEmpty(uCa) ? Float.parseFloat(uCa) : 0f;
        this.pjdy = !StringUtils.isEmpty(pjdy) ? Float.parseFloat(pjdy) : 0f;

        this.aA = !StringUtils.isEmpty(aA) ? Float.parseFloat(aA) : 0f;
        this.aB = !StringUtils.isEmpty(aB) ? Float.parseFloat(aB) : 0f;
        this.aC = !StringUtils.isEmpty(aC) ? Float.parseFloat(aC) : 0f;
        this.pjdl = !StringUtils.isEmpty(pjdl) ? Float.parseFloat(pjdl) : 0f;
    }

    /**
     * @param newPjdy
     * @param newPjdl
     * @param newGlys
     * @param cdxl
     * @param djEddy
     * @param djEddl
     * @param djEdgl
     * @param djEdxl
     * @param djKzdl
     * @param djKzgl
     * @param djEdglys
     * @param djJs
     * @param djWgjjdl
     */
    public Map<String, String> cal(String newPjdy, String newPjdl, String newGlys, String cdxl, String djEddy, String djEddl, String djEdgl, String djEdxl, String djKzdl, String djKzgl, String djEdglys, String djJs, String djWgjjdl) {

        Map<String, String> resultMap = new HashMap<>();

        float newPjdyF = !StringUtils.isEmpty(newPjdy) ? Float.parseFloat(newPjdy) : 0f;
        float newPjdlF = !StringUtils.isEmpty(newPjdl) ? Float.parseFloat(newPjdl) : 0f;

        float diffDY = (newPjdyF - pjdy);

        System.out.println("newPjdyF: " + newPjdyF);
        System.out.println("pjdy: " + pjdy);
        System.out.println("diffDY: " + diffDY);

        this.uAb = this.uAb == 0f ? this.uAb : (this.uAb + diffDY);
        this.uBc = this.uBc == 0f ? this.uBc : (this.uBc + diffDY);
        this.uCa = this.uCa == 0f ? this.uCa : (this.uCa + diffDY);

        float diffDL = (newPjdlF - pjdl);

        System.out.println("newPjdlF: " + newPjdlF);
        System.out.println("pjdl: " + pjdl);
        System.out.println("diffDL: " + diffDL);
        this.aA = this.aA == 0f ? this.aA : (this.aA + diffDL);
        this.aB = this.aB == 0f ? this.aB : (this.aB + diffDL);
        this.aC = this.aC == 0f ? this.aC : (this.aC + diffDL);

        resultMap.put("A相电流", String.format("%.2f", aA));
        resultMap.put("B相电流", String.format("%.2f", aB));
        resultMap.put("C相电流", String.format("%.2f", aC));

        resultMap.put("AB相电压", String.format("%.2f", uAb));
        resultMap.put("BC相电压", String.format("%.2f", uBc));
        resultMap.put("CA相电压", String.format("%.2f", uCa));

        // 如果功率因数为0 ，则赋值为1 ，否则无法计算
        if (StringUtils.isEmpty(newGlys) || Float.parseFloat(newGlys) == 0) {
            this.glys = 1F;
        }else {
            this.glys = Float.parseFloat(newGlys);
        }

        // 视在功率
        float szgl = ((aA * uAb) + (aB * uBc) + (aC * uCa)) / 1000f;
        //计算公式是通过平均电流乘以平均电压乘以3
        //float szgl = (newPjdyF * newPjdlF) * 3 /1000;
        // 电机功率 \ 有功功率
        float ygglF = (szgl * this.glys) / 1.732F;

        float cdxlF = str2F(cdxl);
        float djEddyF = str2F(djEddy);
        float djEddlF = str2F(djEddl);
        float djEdglF = str2F(djEdgl);
        float djEdxlF = str2F(djEdxl);
        float djJsF = str2F(djJs);
        float djKzdlF = str2F(djKzdl);
        float djKzglF = str2F(djKzgl);
        float djEdglysF = str2F(djEdglys);
        float djWgjjdlF = str2F(djWgjjdl);

        //  额定有功损耗 = （1/额定效率 * 100 -1）* 额定功率
        float edyzgshVel = (1f / djEdxlF * 100f - 1f) * djEdglF;

        //  负载系数 = （sqrt(额定功率 * 额定功率 /4 + (额定有功损耗 - 空载功率) * （输入功率 - 空载功率）)-额定功率/2） /(额定有功损耗 -空载功率)
        boolean isGetFzxs = false;
        float fzxsRes = 0;
        float fo = (djEdglF * djEdglF) / 4 + (edyzgshVel - djKzglF) * (ygglF - djKzglF);
        if (fo >= 0) {
            isGetFzxs = true;
            fzxsRes = (float) ((Math.sqrt(fo) - djEdglF / 2f) / (edyzgshVel - djKzglF));
            resultMap.put("负载系数", String.format("%.2f", fzxsRes));
        }

        //  输出功率 = 电机额定功率 * 负载系数
        boolean isGetScgl = false;
        float scglRes = 0f;
        if (isGetFzxs) {
            isGetScgl = true;
            scglRes = djEdglF * fzxsRes;
            scglRes = scglRes < 0 ? 0 : scglRes;
            resultMap.put("输出功率", String.format("%.2f", scglRes));
        }

        //  电机效率 = 输出功率 / 输入功率 = 输出功率 / 电机功率 = 输出功率 / 有功功率
        boolean isGetDjxl = false;
        float djxlRes = 0f;
        if (isGetScgl) {
            isGetDjxl = true;
            if (ygglF != 0) {
                djxlRes = scglRes / ygglF;
            }
            djxlRes = djxlRes > 1 ? 1 : djxlRes;
            djxlRes = djxlRes < 0 ? 0 : djxlRes;
            resultMap.put("电机效率", String.format("%.4f", djxlRes));
        }

        //  轴功率 = 有功功率 * 电机效率 * 传动效率
        boolean isGetZgl = false;
        float zglRes = 0f;
        if (isGetDjxl) {
            isGetZgl = true;
            zglRes = ygglF * cdxlF * djxlRes;
            resultMap.put("轴功率", String.format("%.2f", zglRes));
        }

//        综合效率 = 负载系数 * 额定功率 / ( 负载系数 * 额定功率 + 综合功率损耗) * 100
//        综合功率损耗 = 空载功率 + 负载系数 * 负载系数 * （额定有功损耗 - 空载功率） + 无功经济当量 * （空载无功功率 + 负载系数 * 负载系数 *（额定负载时无功功率 - 空载无功功率））
//        空载无功功率 = Sqrt（3 * 额定电压 * 额定电压 * 空载电流 * 空载电流 * 0.000001 - 空载功率 * 空载功率）
//        额定有功损耗 = （1 / 额定效率 * 100 -1）* 额定功率
//        额定负载时无功功率 = 额定功率 / 额定效率 * 100 * Tan（额定电压电流相位角 / 180 *Pi）
//        额定电压电流相位角 = （Cos（额定功率 / 额定效率 * 100 * 1000 / Sqrt(3)/额定电压/额定电流））/Pi * 180
//        额定综合效率 = 额定功率 /( 额定功率 + 额定综合功率损耗) * 100
//        额定综合功率损耗 = 额定有功损耗 + 无功经济当量 * 额定负载时无功功率

        float eddydlxwjVel = (float) ((Math.acos(djEdglF / djEdxlF * 100000f / Math.sqrt(3f) / djEddyF / djEddlF)) / Math.PI * 180F);
        float veF = 3f * djEddyF * djEddyF * djKzdlF * djKzdlF * 0.000001f - djKzglF * djKzglF;

        float zhxlRes = 0f;
        boolean isGetZhxl = false;
        String yxztRes = "";
        boolean isGetYxzt = false;

        if ((eddydlxwjVel / 180f * Math.PI) % (Math.PI / 2f) != 0f && isGetFzxs && veF > 0f) {
            // 额定负载时无功功率
            float edfzswgglVel = (float) (djEdglF / djEdxlF * 100f * Math.tan(eddydlxwjVel / 180f * Math.PI));
            // 额定有功损耗
            float edygshVel = (1f / djEdxlF * 100f - 1f) * djEdglF;
            // 空载无功功率
            float kzwgglVel = (float) Math.sqrt(veF);
            // 综合功率损耗
            float zhglshVel = (float) (djKzglF + fzxsRes * fzxsRes * (edygshVel - djKzglF) + djWgjjdlF * (kzwgglVel + fzxsRes * fzxsRes * (edfzswgglVel - kzwgglVel)));
            float edzhglshVel = edygshVel + djWgjjdlF * edfzswgglVel;
            float edzhxlVel = djEdglF / (djEdglF + edzhglshVel) * 100f;
            // 综合效率
            zhxlRes = fzxsRes * djEdglF / (fzxsRes * djEdglF + zhglshVel) * 100f;
            zhxlRes = zhxlRes < 0 ? 0 : zhxlRes;
            zhxlRes = zhxlRes > 100 ? 100 : zhxlRes;
            isGetZhxl = true;
            resultMap.put("综合效率", String.format("%.4f", zhxlRes));

//        综合效率 >= 额定综合效率  ---》 经济运行
//        综合效率 >= 额定综合效率 * 0.6  ---》 合理运行
//        综合效率 >= 低效运行

            yxztRes = "经济运行";
            if (zhxlRes >= edzhxlVel) {
                yxztRes = "经济运行";
            } else if (zhxlRes > edzhxlVel * 0.6f) {
                yxztRes = "合理运行";
            } else {
                yxztRes = "非经济运行";
            }
            resultMap.put("运行状态", yxztRes);
            isGetYxzt = true;
        }

        return resultMap;

    }


    public float str2F(String strVel) {
        return Float.parseFloat(strVel);
    }

}
